home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Miscellaneous / Headlines Code / Jamie’s PD Code ƒ / JMassMalloc.c < prev    next >
Text File  |  1992-08-03  |  3KB  |  155 lines
  1. /*
  2.  * JMassMalloc.c
  3.  *
  4.  * "Jamie's Mass Malloc," version 1.0
  5.  *
  6.  * This is a really cheap-o version of malloc, in that you can't
  7.  * free up individual allocations, you have to free everything
  8.  * at once.  I wrote it for my own personal use, it works for me,
  9.  * but I guarantee absolutely nothing about it.
  10.  *
  11.  * As I say, it's not too smart.  On the bright side, though, it
  12.  * takes less than 400 bytes of object code, and it's pretty damn
  13.  * fast even without dropping into assembly language.  :-)
  14.  *
  15.  * This code, including JMassMalloc.h, is in the public domain.
  16.  * That means I don't have any more rights to it than anyone else;
  17.  * you may freely use this code however you wish.  If you modify
  18.  * it, though, please do me the courtesy of putting a different
  19.  * version number on it.  I can be contacted at the AppleLink
  20.  * address "j.mccarthy" or the Internet address
  21.  * "j.mccarthy@applelink.apple.com".
  22.  *
  23.  */
  24.  
  25.  
  26.  
  27. /******************************/
  28.  
  29. #include "JMassMalloc.h"
  30.  
  31. /******************************/
  32.  
  33.     /* Never get a pointer less than 16K. */
  34. #define kJMMMinAllocSize (16384L)
  35.  
  36.     /* Word-align the allocations. */
  37. #define kJMMAlignment (2)
  38.  
  39. /******************************/
  40.  
  41. typedef struct jmmAllocation {
  42.     struct jmmAllocation        *next;
  43.     unsigned long                used;
  44.     unsigned long                size;
  45. } jmmAllocationStruct;
  46.  
  47. /******************************/
  48.  
  49. jmmAllocationStruct *jmmHead;
  50.  
  51. /******************************/
  52.  
  53. Boolean jmmHeadHasFreeSpace(unsigned long nBytes);
  54. void *jmmAllocateNewMem(unsigned long nBytes);
  55. void *jmmReserveOldMem(unsigned long nBytes);
  56.  
  57. /******************************/
  58.  
  59.  
  60.  
  61. void setupJMM(void)
  62. {
  63.     jmmHead = NULL;
  64. }
  65.  
  66.  
  67.  
  68. void *malloc(unsigned long nBytes)
  69. {
  70.     if (jmmHeadHasFreeSpace(nBytes)) return jmmReserveOldMem(nBytes);
  71.     else return jmmAllocateNewMem(nBytes);
  72. }
  73.  
  74.  
  75.  
  76. void free(void *memToFree)
  77. {
  78.     /*
  79.      * This implementation of malloc only lets you free up everything
  80.      * at once.  Sorry.  free() is only here for compatibility.
  81.      */
  82. }
  83.  
  84.  
  85.  
  86. void shutdownJMM(void)
  87. {
  88.     register jmmAllocationStruct *theNext;
  89.     
  90.     while (jmmHead != NULL) {
  91.         theNext = jmmHead->next;
  92.         DisposPtr(jmmHead);
  93.         jmmHead = theNext;
  94.     }
  95. }
  96.  
  97.  
  98.  
  99. /******************************/
  100.  
  101.  
  102.  
  103. Boolean jmmHeadHasFreeSpace(unsigned long nBytes)
  104. {
  105.     if (jmmHead == NULL) return FALSE;
  106.     else return ( (jmmHead->size - jmmHead->used) >= nBytes );
  107. }
  108.  
  109.  
  110.  
  111. void *jmmAllocateNewMem(unsigned long nBytes)
  112. {
  113.     jmmAllocationStruct *oldHead;
  114.     register jmmAllocationStruct *newHead;
  115.     register unsigned long actualAllocSize;
  116.     
  117.     if (nBytes == 0) return NULL;
  118.     
  119.     oldHead = jmmHead;
  120.     
  121. #if (kJMMAlignment > 1)
  122.     nBytes = ( (nBytes-1) / kJMMAlignment + 1 ) * kJMMAlignment;
  123. #endif
  124.     actualAllocSize = nBytes;
  125.     if (actualAllocSize < kJMMMinAllocSize) actualAllocSize = kJMMMinAllocSize;
  126.     actualAllocSize += sizeof(jmmAllocationStruct);
  127.     
  128.     newHead = (jmmAllocationStruct*) NewPtr(actualAllocSize);
  129.     if (newHead == NULL) return NULL;
  130.     
  131.     jmmHead = newHead;
  132.     newHead->next = oldHead;
  133.     newHead->used = nBytes + sizeof(jmmAllocationStruct);
  134.     newHead->size = actualAllocSize;
  135.     
  136.     return &(newHead[1]); // ugly, but it works
  137. }
  138.  
  139.  
  140.  
  141. void *jmmReserveOldMem(unsigned long nBytes)
  142. {
  143.     void *theReservedMem;
  144.     
  145.     if (nBytes == 0) return NULL;
  146.     
  147.     theReservedMem = & ( ((char*) jmmHead) [jmmHead->used] );
  148. #if (kJMMAlignment > 1)
  149.     nBytes = ( (nBytes-1) / kJMMAlignment + 1 ) * kJMMAlignment;
  150. #endif
  151.     jmmHead->used += nBytes;
  152.     
  153.     return theReservedMem;
  154. }
  155.